/*->c.ckcmai */


#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "h.os"
#include "h.bbc"
#include "h.wimp"
#include "h.flex"

#include "h.def"


#include "h.wos"
#include "h.timex"
#include "h.key"
#include "h.trans"
#include "h.term"
#include "h.ftp"
#include "h.batch"
#include "h.mym"
#include "h.xmodem"
#include "h.serial"
#include "h.view"
#include "h.xext"


#include "ckcdeb.h"                     /* Debug & other symbols */
#include "ckcker.h"                     /* Kermit symbols */
#include "ckcfil.h"                     /* File-related symbols */

#include "h.ckcdef"


/*****************************************************************************/


char *hlptxt; /* = "Hearsay Kermit Server REMOTE Commands:\n\
\n\
GET files  REMOTE CWD [dir]    REMOTE DIRECTORY [files]\n\
SEND files REMOTE SPACE [dir]  REMOTE HOST command\n\
           REMOTE DELETE files REMOTE TYPE files\n\
BYE        FINISH              REMOTE HELP\n\
\n\0"; */

char *srvtxt; /* = "\r\n\
Hearsay Kermit server starting. Return to your local machine by typing\r\n\
its escape sequence for closing the connection, and issue further\r\n\
commands from there. To shut down the Hearsay Kermit server, issue the\r\n\
BYE command to terminate Hearsay, or the FINISH command and then reconnect.\
\r\n\r\n\0"; */



/* Declarations for Send-Init Parameters */

int spsiz = DSPSIZ,                     /* Current packet size to send */
    spmax = DSPSIZ,             /* (PWP) Biggest packet size we can send */
                                /* (see rcalcpsz()) */
    spsizf = 0,                         /* Flag to override what you ask for */
    rpsiz =  DRPSIZ,                    /* Biggest we want to receive */
    urpsiz = DRPSIZ,                    /* User-requested rpsiz */
    maxrps = MAXRP,                     /* Maximum incoming long packet size */
    maxsps = MAXSP,                     /* Maximum outbound l.p. size */
    maxtry = MAXTRY,                    /* Maximum retries per packet */
    wslots = 1,                         /* Window size in use */
    wslotsr,                            /* Window size requested */
    wslotsn,                            /* Window size negotiated */
    timeouts = 0,                       /* For statistics reporting */
    spackets = 0,                       /*  ... */
    rpackets = 0,                       /*  ... */
    retrans = 0,                        /*  ... */
    crunched = 0,                       /*  ... */
    wmax = 0,                           /*  ... */
    timint = DMYTIM,                    /* Timeout interval I use */
    srvtim = DSRVTIM,                   /* Server command wait timeout */
    rtimo = URTIME,                     /* Timeout I want you to use */
    timef = 0,                          /* Flag to override what you ask */
    npad = MYPADN,                      /* How much padding to send */
    mypadn = MYPADN,                    /* How much padding to ask for */
    bctr = 1,                           /* Block check type requested */
    bctu = 1,                           /* Block check type used */
    ebq =  MYEBQ,                       /* 8th bit prefix */
    ebqflg = 0,                         /* 8th-bit quoting flag */
    rqf = -1,                           /* Flag used in 8bq negotiation */
    rq = 0,                             /* Received 8bq bid */
    sq = 'Y',                           /* Sent 8bq bid */
    rpt = 0,                            /* Repeat count */
    rptq = MYRPTQ,                      /* Repeat prefix */
    rptflg = 0;                         /* Repeat processing flag */

int capas = 9,                          /* Position of Capabilities */
    atcapb = 8,                         /* Attribute capability */
    atcapr = 1,                         /*  requested */
    atcapu = 0,                         /*  used */
    swcapb = 4,                         /* Sliding Window capability */
    swcapr = 0,                         /*  requested */
    swcapu = 0,                         /*  used */
    lpcapb = 2,                         /* Long Packet capability */
    lpcapr = 1,                         /*  requested */
    lpcapu = 0;                         /*  used */



/* Flags for whether to use particular attributes */


int atenci = 0,                         /* Encoding in */
    atenco = 0,                         /* Encoding out */
    atdati = 1,                         /* Date in */
    atdato = 1,                         /* Date out */
    atdisi = 1,                         /* Disposition in/out */
    atdiso = 1,
    atleni = 1,                         /* Length in/out (both kinds) */
    atleno = 1,
    atblki = 1,                         /* Blocksize in/out */
    atblko = 1,
    attypi = 1,                         /* File type in/out */
    attypo = 1,
    atsidi = 1,                         /* System ID in/out */
    atsido = 1,
    atsysi = 1,                        /* System-dependent parameters in/out */
    atsyso = 1;

CHAR padch = MYPADC,                    /* Padding character to send */
     mypadc = MYPADC,                   /* Padding character to ask for */
     seol = MYEOL,                      /* End-Of-Line character to send */
     eol = MYEOL,                       /* End-Of-Line character to look for */
     ctlq = CTLQ,                       /* Control prefix in incoming data */
     myctlq = CTLQ;                     /* Outbound control character prefix */

struct zattr iattr;                     /* Incoming file attributes */

/* Packet-related variables */

int pktnum = 0,                         /* Current packet number */
    prvpkt = -1,                        /* Previous packet number */
    sndtyp,                             /* Type of packet just sent */
    rsn,                                /* Received packet sequence number */
    rln,                                /* Received packet length */
    size,                               /* Current size of output pkt data */
    osize,                              /* Previous output packet data size */
    maxsize,                            /* Max size for building data field */
    spktl = 0,                          /* Length packet being sent */
    rprintf,                            /* REMOTE PRINT flag */
    rmailf;                             /* MAIL flag */


CHAR * padbuf;


CHAR

/*    padbuf[95], */                    /* Buffer for send-padding */
    *recpkt,
    *rdatap,                            /* Pointer to received packet data */
    *data,                              /* Pointer to send-packet data */
/*  srvcmd[MAXRP+4], */                 /* Where to decode server command */
    *srvptr,                            /* Pointer to above */
    mystch = SOH,                       /* Outbound packet-start character */
    stchr = SOH;                        /* Incoming packet-start character */

CHAR * srvcmd;


/* File-related variables */

/* CHAR filnam[256]; */                 /* Name of current file. */

CHAR * filnam;

int nfils;                              /* Number of files in file group */
int fsize;                              /* Size of current file */


int fblksiz;
int frecl;
int forg;
int frecfm;
int fncact;
int fcctrl;




/* Communication line variables */


int  speed;                             /* Line speed */

int parity,                             /* Parity specified, 0,'e','o',etc */


/*  turn = 0,      */                   /* Line turnaround handshake flag */
/*  turnch = XON,  */                   /* Line turnaround character */
    delay = DDELAY;                     /* Initial delay before sending */

/* Networks for SET HOST */

    int network = 0;                    /* Network vs tty connection */


/* Other recent additions */

    int fncact = XYFX_B;                /* Filename collision action */


/* Statistics variables */

int  filcnt,                     /* Number of files in transaction */
     flci,                       /* Characters from line, current file */
     flco,                       /* Chars to line, current file  */
     tlci,                       /* Chars from line in transaction */
     tlco,                       /* Chars to line in transaction */
     ffc,                        /* Chars to/from current file */
     tfc,                        /* Chars to/from files in transaction */
     rptn;                       /* Repeated characters compressed */

/* int tsecs;  */                /* Seconds for transaction */

/* Flags */

int deblog = 0,                         /* Flag for debug logging */
    debses = 0,                         /* Flag for DEBUG SESSION */
    seslog = 0,                         /* Session logging */
    tralog = 0,                         /* Transaction logging */
    displa = 0,                         /* File transfer display on/off */
    xflg   = 0,                         /* Flag for X instead of F packet */
    hcflg  = 0,                         /* Doing Host command */
    fncnv  = 1,                         /* Flag for file name conversion */
    binary = 1,                         /* Flag for binary file */
    savmod = 0,                         /* Saved file mode (whole session) */
    bsave  = 0,                         /* Saved file mode (per file) */
    bsavef = 0,                         /* Flag if bsave was used. */
    cmask  = 0177,                      /* Connect byte mask */
    fmask  = 0377,                      /* File byte mask */
    warn   = 0,                         /* Flag for file warning */
    quiet  = 0,                         /* Be quiet during file transfer */
    local  = 0,                         /* Flag for external tty vs stdout */
    server = 0,                         /* Flag for being a server */
    cnflg  = 0,                         /* Connect after transaction */
    cxseen = 0,                         /* Flag for cancelling a file */
    czseen = 0,                         /* Flag for cancelling file group */
    discard = 0,                        /* Flag for file to be discarded */
    keep = 0,                           /* Keep incomplete files */
    unkcs = 1,                          /* Keep file w/unknown character set */
    nakstate = 0;                       /* In a state where we can send NAKs */



/* Variables passed from command parser to protocol module */


char sstate;                       /* Starting state for automaton */
char *cmarg;                       /* Pointer to command data */
char *cmarg2;                      /* Pointer to 2nd command data */




/* Miscellaneous */
/*
char zinbuffer[INBUFSIZE];
char zoutbuffer[INBUFSIZE];
 */

char * zinbuffer;
char * zoutbuffer;

char *zinptr;
char *zoutptr;
int  zincnt;
int  zoutcnt;




/* from c.ckcfn3  */

int winlo;                              /* packet number at low window edge  */

int bigsbufsiz;
int bigrbufsiz;

int sbufnum;                            /* number of free buffers */
int dum001 = 1234;                      /* protection... */


int sbufuse[MAXWS];                     /* buffer in-use flag */


int dum003 = 1111;
int rbufnum;                            /* number of free buffers */
int dum002 = 4321;                      /* more protection */


int rbufuse[MAXWS];                     /* buffer in-use flag */



int sseqtbl[64];                        /* sequence # to buffer # table */
int rseqtbl[64];                        /* sequence # to buffer # table */

/* struct pktinfo s_pkt[MAXWS]; */      /* array of pktinfo structures */
/* struct pktinfo r_pkt[MAXWS]; */      /* array of pktinfo structures */

struct pktinfo * s_pkt;
struct pktinfo * r_pkt;


/* CHAR bigsbuf[BIGSBUFSIZ + 5];  */         /* Send-packet buffer area */
/* CHAR bigrbuf[BIGRBUFSIZ + 5];  */         /* Receive-packet area */


CHAR * bigsbuf;
CHAR * bigrbuf;


/* from c.ckcfns */

/* CHAR encbuf[ENCBUFL];  */            /* Because getpkt always writes */
                                        /* into "data", but when this */
                                        /* function is called, "data" might */
                                        /* might not be allocated. */

CHAR * encbuf;


/* char cmdstr[128];      */            /* Unix system command string */

char * cmdstr;


static char * kermitbuff;          /* space for all Kermit buffers */
static int    kboffset;


#define KGUARD 16

#define KBUFFSIZE (INBUFSIZE*2+(BIGSBUFSIZ+5)*2+ENCBUFL+128+(2*MAXWS*sizeof(struct pktinfo))+256+(MAXRP+4)+95+11*KGUARD*3)



void bootkermit(void)
{
 char temp[512];

 hlptxt=transtoken("KMH");
 srvtxt=transtoken("KMS");

 strcpy(temp,hlptxt);      /* expanding \n's etc. */
 sprintf(hlptxt,temp);
 strcpy(temp,srvtxt);
 sprintf(srvtxt,temp);

 flex_alloc((flex_ptr)&kermitbuff,0);
}


char * kalloc(int size)
{
 int oldoffset=kboffset;
 if(size & 0x3) size+=(4-(size & 0x3));

 kboffset+=size+2*KGUARD;
 return(kermitbuff+oldoffset+KGUARD);
}



int kermitalloc(void)
{
 kboffset=0;

 if(flex_extende((flex_ptr)&kermitbuff,KBUFFSIZE))
 {
  zinbuffer=kalloc(INBUFSIZE);
  zoutbuffer=kalloc(INBUFSIZE);
  bigsbuf=kalloc(BIGSBUFSIZ+5);
  bigrbuf=kalloc(BIGSBUFSIZ+5);
  encbuf=kalloc(ENCBUFL);
  cmdstr=kalloc(128);
  s_pkt=(struct pktinfo *)kalloc(MAXWS*sizeof(struct pktinfo));
  r_pkt=(struct pktinfo *)kalloc(MAXWS*sizeof(struct pktinfo));
  filnam=kalloc(256);
  srvcmd=kalloc(MAXRP+4);
  padbuf=kalloc(95);

  refreshallviews();
  return(1);
 }
  else
  return(0);
}


void kermitfree(void)
{
 flex_extend((flex_ptr)&kermitbuff,0);
 refreshallviews();
}



/*

   sstate                             string data
     'x' (enter server mode)            (none)
     'r' (send a 'get' command)         cmarg, cmarg2
     'v' (enter receive mode)           cmarg2
     'g' (send a generic command)       cmarg
     's' (send files)                   nfils, cmarg & cmarg2
     'c' (send a remote host command)   cmarg

   cmlist is an array of pointers to strings.
   cmarg, cmarg2 are pointers to strings.
   nfils is an integer.

   cmarg can be a filename string (possibly wild), or
      a pointer to a prefabricated generic command string, or
      a pointer to a host command string.
   cmarg2 is the name to send a single file under, or
      the name under which to store an incoming file; must not be wild.
      If it's the name for receiving, a null value means to store the
      file under the name it arrives with.

   nfils is an integer, interpreted as follows:
     -1: filespec (possibly wild) in cmarg, must be expanded internally.
      0: send from stdin (standard input).
     >0: number of files to send, from cmlist.

   if(nfils>0) then use batch for files to send 


 */






/*  B L D L E N  --  Make length-encoded copy of string  */

char * bldlen(char * str,char * dest)
{
 int len;
 len = strlen(str);
 *dest = tochar(len);
 strcpy(dest+1,str);
 return(dest+len+1);
}


/*  S E T G E N  --  Construct a generic command  */

char setgen(char type,char * arg1,char * arg2,char * arg3)
{
 char * upstr;
 char * cp;

 cp=cmdstr;
 *cp++=type;
 *cp=NUL;
 if(*arg1!=NUL)
 {
  upstr=bldlen(arg1,cp);
  if(*arg2!=NUL)
  {
   upstr=bldlen(arg2,upstr);
   if(*arg3 != NUL) bldlen(arg3,upstr);
  }
 }
 cmarg=cmdstr;
 debug(F110,"setgen",cmarg,0);

 return('g');
}






int kermitset(void)
{
 local=0;                         /* And whether it's local or remote. */
 parity=paritybits;               /* Set initial parity, */
 speed=txbitrate;                 /* Get transmission speed. */
 cmarg=cmarg2=NULL;

 if(swcapr)
 {
  swcapu=0;
  wslotsr=5;
  wslotsn=5; 
  wslotsn=wslotsr;
 }
 else
 {
  swcapu=1;
  wslotsr=1;
  wslotsn=1;
  wslotsn=1;
 }

 zsetmode(bctu);

 return(kermitalloc());
}



void kermitunset(void)
{
 kermitfree();
}


void kermitunset2(void)
{
 kermitunset();
 ftpactive=0;
 ftpwarning();
}



int kermitset2(void)
{
 if(ftpactive) return(1);
 if(!kermitset()) return(1);
 ftpline=online;
 ftpactive=1;
 ftp_ok=-1;
 return(0);
}



/* send files */

void kermittx(void)
{
 if(kermitset())
 {                                                                                nfils=txbatchfiles();
  if(nfils)
  {
   sstate='s';
   proto();
   kermitunset();
  }
 }
}


/* receive files */

void kermitrx(void)
{
 if(kermitset())
 {
  sstate='v';
  proto();
  kermitunset();
 }
}



/* get command                     */
/* this comes through ftp code ... */

void kermitdoget(char * getcmd)
{
 if(kermitset())
 {
  sstate='r';
  cmarg=cmdstr;
  strcpy(cmarg,getcmd);

  proto();
  kermitunset();
 }
}



/* go into server mode */

void kermitdoserver(void)
{
 if(kermitset())
 {
  sstate='x';
  proto();

  kermitunset();
 }
}



/* bye */

void kermitdobye(void)
{
 if(kermitset2()) return;
 sstate=setgen('L',"","","");
 proto();
 kermitunset2();
}


void skermitdobye(int fp)
{
 fp=0;
 kermitdobye();
}



/* finish */

void kermitdofinish(void)
{
 if(kermitset2()) return;
 sstate=setgen('F',"","","");
 proto();
 kermitunset2();
}


void skermitdofinish(int fp)
{
 fp=0;
 kermitdofinish();
}




/* remote dir command */

void kermitdoremdir(char * cmd)
{
 if(kermitset2()) return;
 sstate=setgen('D',cmd,"","");
 proto();
 kermitunset2();
}


void skermitdoremdir(int fp)
{
 char string[256];
 strcpy(string,stringptr(stack[fp]));
 kermitdoremdir(string);
}



/* remote change dir */

void kermitdochangeremdir(char * cmd)
{
 if(kermitset2()) return;
 sstate=setgen('C',cmd,"","");
 proto();
 kermitunset2();
}

void skermitdochangeremdir(int fp)
{
 char string[256];
 strcpy(string,stringptr(stack[fp]));
 kermitdochangeremdir(string);
}



/* remote type file */

void kermitdotype(char * cmd)
{
 if(kermitset2()) return;
 sstate=setgen('T',cmd,"","");
 proto();
 kermitunset2();
}

void skermitdotype(int fp)
{
 char string[256];
 strcpy(string,stringptr(stack[fp]));
 kermitdotype(string);
}




/* remote delete file */

void kermitdodelete(char * cmd)
{
 if(kermitset2()) return;
 sstate=setgen('E',cmd,"","");
 proto();
 kermitunset2();
}


void skermitdodelete(int fp)
{
 char string[256];
 strcpy(string,stringptr(stack[fp]));
 kermitdodelete(string);
}



/* remote host command */

void kermitdoremote(char * cmd)
{
 if(kermitset2()) return;
 sstate='c';
 cmarg=cmdstr;
 strcpy(cmarg,cmd);
 proto();
 kermitunset2();
}

void skermitdoremote(int fp)
{
 char string[256];
 strcpy(string,stringptr(stack[fp]));
 kermitdoremote(string);
}




/*****************************************************************************/


#ifdef NEVER


static void kermitgetchar(char * val,int * menu)
{
 int c;
 c=asciichar(menu);
 if(c!=-1) *val=c;
}



static void setrxeqtx(void)
{
 urpsiz=spsiz;
 mypadn=npad;
 mypadc=padch;
 stchr=mystch;
 eol=seol;
 rtimo=timint;
 ctlq=myctlq;
}



static int rxeqtx(void)
{
 return(
        urpsiz==spsiz &&
        mypadn==npad  &&
        mypadc==padch &&
        stchr==mystch &&
        eol==seol     &&
        rtimo==timint &&
        ctlq==myctlq
       );
}




void setpoptxparams(void)
{
 asciiwrchar(ktxpadchar_menu,padch);
 asciiwrchar(ktxsohchar_menu,mystch);
 asciiwrchar(ktxeolchar_menu,seol);
 asciiwrchar(ktxctrlch_menu,myctlq);

 asciiwrpace(ktxpacksize_menu,spsiz);
 asciiwrpace(ktxpadsize_menu,npad);
 asciiwrpace(ktxtime_menu,timint);
}


void setpoprxparams(void)
{
 asciiwrchar(krxpadchar_menu,mypadc);
 asciiwrchar(krxsohchar_menu,stchr);
 asciiwrchar(krxeolchar_menu,eol);
 asciiwrchar(krxctrlch_menu,ctlq);

 asciiwrpace(krxpacksize_menu,urpsiz);
 asciiwrpace(krxpadsize_menu,mypadn);
 asciiwrpace(krxtime_menu,rtimo);
}





void setpopkermit(void)
{
 int i;

 setpoptxparams();
 setpoprxparams();

 tickst(kconfig_menu,2,rxeqtx());
 tickst(kconfig_menu,3,binary);
 tickst(kconfig_menu,4,swcapr);
 tickst(kconfig_menu,5,ebqflg);

 asciiwrchar(k8bitquote_menu,ebq);

 for(i=0;i<3;i++) tickst(kblockcheck_menu,i,bctr==(i+1));
}





void decodetxparams(int m4)
{
 switch(m4)
 {
  case 0: /* max packet size */
         asciigetpace(ktxpacksize_menu,&spsiz);
         break;

  case 1: /* padding size */
         asciigetpace(ktxpadsize_menu,&npad);
         break;

  case 2: /* padding char */
         kermitgetchar(&padch,ktxpadchar_menu);
         break;

  case 3: /* start char */
         kermitgetchar(&mystch,ktxsohchar_menu);
         break;

  case 4: /* end char */
         kermitgetchar(&seol,ktxeolchar_menu);
         break;

  case 5: /* timeout */
         asciigetpace(ktxtime_menu,&timint);
         break;

  case 6: /* Ctrl q */
         kermitgetchar(&myctlq,ktxctrlch_menu);
         break;
 }
}



void decoderxparams(int m4)
{
 switch(m4)
 {
  case 0: /* max packet size urpsiz */
         asciigetpace(krxpacksize_menu,&urpsiz);
         break;

  case 1: /* padding size */
         asciigetpace(krxpadsize_menu,&mypadn);
         break;

  case 2: /* padding char */
         kermitgetchar(&mypadc,krxpadchar_menu);
         break;

  case 3: /* start char */
         kermitgetchar(&stchr,krxsohchar_menu);
         break;

  case 4: /* end char */
         kermitgetchar(&eol,krxeolchar_menu);
         break;

  case 5: /* timeout */
         asciigetpace(krxtime_menu,&rtimo);
         break;

  case 6: /* Ctrl q */
         kermitgetchar(&ctlq,krxctrlch_menu);
         break;
 }
}






void decodeconfig(int m3,int m4)
{
 switch(m3)
 {
  case 0: /* TX params */
         decodetxparams(m4);
         break;

  case 1: /* RX params */
         decoderxparams(m4);
         break;

  case 2: /* RX==TX */
         setrxeqtx();
         break;

  case 3: /* Binary */
         binary^=1;
         break;

  case 4: /* Windows */
         swcapr^=1;
         break;

  case 5: /* 8 bit quote */
         if(m4==-1) ebqflg^=1;
         else       kermitgetchar((char*)&ebq,k8bitquote_menu);
         break;

  case 6: /* block check */
         if(m4>=0 && m4<=2) bctr=m4+1;
         break;

 }
}


#endif




void setpopkermit(void)
{

}



void decodekermit(int m2,int m3,int m4)
{
 switch(m2)
 {
  case 0:  /* go server */
         kermitserver();
         break;

  case 1: /* get */
         kermitget(menuaddr(kget_menu,0)); /* goes through ftp code */
         break;

  case 2: /* rem dir */
         kermitdoremdir(menuaddr(kremdir_menu,0));
         break;

  case 3: /* rem cwd */
         kermitdochangeremdir(menuaddr(kcwdir_menu,0));
         break;

  case 4: /* rem type command */
         kermitdotype(menuaddr(ktype_menu,0));
         break;

  case 5: /* rem delete command */
         kermitdodelete(menuaddr(kdelete_menu,0));
         break;

  case 6: /* rem host command */
         kermitdoremote(menuaddr(khost_menu,0));
         break;

  case 7: /* finish */
         kermitdofinish();
         break;

  case 8: /* bye */
         kermitdobye();
         break;

  case 9: /* config */
         break;
 }
 m3=m4=0;
}



/*****************************************************************************/

static int tempbinary;
static int tempswcapr;
static int tempebqflg;
static int tempbctr;


              /* N L R D U */

static char entryiclst[15][5]=
{
          9,          0,          25,          10,            0,
         10,          0,          26,          11,            9,
         11,          0,          27,          12,           10,
         12,          0,          28,          13,           11,
         13,          0,          29,          14,           12,
         14,          0,          30,          15,           13,
         15,          0,          31,          25,           14,
         25,          9,           0,          26,           15,
         26,         10,           0,          27,           25,
         27,         11,           0,          28,           26,
         28,         12,           0,          29,           27,
         29,         13,           0,          30,           28,
         30,         14,           0,          31,           29,
         31,         15,           0,          35,           30,
         35,          0,           0,           0,           31
};




void kermitkey(int * key)
{
 int cicon;
 int j;
 int ch;

 ch=*key;

 switch(ch)
 {
       case 27:
               zapmenu();
               break;

       case CR:
               ch=CDOWN;

    case 0x18E:
    case 0x18F:
    case 0x19C:
    case 0x19D:
    case 0x19E:
    case 0x19F:
               ch&=0x18F;
               for(j=0;j<15;j++) if(entryiclst[j][0]==icon) break;
               cicon=entryiclst[j][(ch-0x18B)];
               if(cicon) iecarrot(whandle[KERMIT],cicon);
               break;

    default:return;
 }
 *key=-1;
}




/* static char * bcnames[3]={"6 bit sum","12 bit sum","16 bit CRC"}; */

static char * bcnames[3]={"KN0","KN1","KN2"};


void kwrbc(void)
{
 writeicon(whandle[KERMIT],39,transtoken(bcnames[tempbctr-1]));
}




static void kermitgetchar(char * val,int handle,int icon)
{
 int c;
 c=xasciichar(handle,icon);
 if(c!=-1) *val=c;
}



void kermitok(void)
{
                                    /* TX */

 xasciigetpace(ewindow,9,&spsiz);    /* max packet size */
 xasciigetpace(ewindow,10,&npad);    /* padding size */
 kermitgetchar(&padch,ewindow,11);   /* padding char */
 kermitgetchar(&mystch,ewindow,12);  /* start char */
 kermitgetchar(&seol,ewindow,13);    /* end char */
 xasciigetpace(ewindow,14,&timint);  /* timeout */
 kermitgetchar(&myctlq,ewindow,15);  /* Ctrl q */

                                    /* RX */

 xasciigetpace(ewindow,25,&urpsiz);  /* max packet size urpsiz */
 xasciigetpace(ewindow,26,&mypadn);  /* padding size */
 kermitgetchar(&mypadc,ewindow,27);  /* padding char */
 kermitgetchar(&stchr,ewindow,28);   /* start char */
 kermitgetchar(&eol,ewindow,29);     /* end char */
 xasciigetpace(ewindow,30,&rtimo);   /* timeout */
 kermitgetchar(&ctlq,ewindow,31);    /* Ctrl q */

 kermitgetchar((char*)&ebq,ewindow,35);

 binary=tempbinary;
 swcapr=tempswcapr;
 ebqflg=tempebqflg;
 bctr=tempbctr;
}



void kermiticon(void)
{
 int i;

 switch(icon)
 {

  case 37:
  case 38:
          if((buttons==0x4 && icon==37) || (buttons==0x1 && icon==38))
          {
           if(tempbctr>1)
           {
            tempbctr--;
            kwrbc();
           }
          }
          else
          if((buttons==0x1 && icon==37) || (buttons==0x4 && icon==38))
          {
           if(tempbctr<3)
           {
            tempbctr++;
            kwrbc();
           }
          }
          break;

  case 32:
          selectst(ewindow,32,tempbinary^=1);
          break;

  case 33:
          selectst(ewindow,33,tempswcapr^=1);
          break;

  case 34:
          selectst(ewindow,34,tempebqflg^=1);
          break;

  case 40:
          for(i=9;i<16;i++) writeiconf(ewindow,25+i-9,iconaddr(ewindow,i));
          break;

  case 41:
          kermitok();
          if(buttons==0x4) zapmenu();
          break;

 }
}


int kermitsetup(void)
{
 int handle=createwindow(KERMIT);
 
 xasciiwrchar(handle,11,padch);
 xasciiwrchar(handle,12,mystch);
 xasciiwrchar(handle,13,seol);
 xasciiwrchar(handle,15,myctlq);

 xasciiwrpace(handle,9,spsiz);
 xasciiwrpace(handle,10,npad);
 xasciiwrpace(handle,14,timint);

 xasciiwrchar(handle,27,mypadc);
 xasciiwrchar(handle,28,stchr);
 xasciiwrchar(handle,29,eol);
 xasciiwrchar(handle,31,ctlq);

 xasciiwrpace(handle,25,urpsiz);
 xasciiwrpace(handle,26,mypadn);
 xasciiwrpace(handle,30,rtimo);

 selectst(handle,32,binary);
 selectst(handle,33,swcapr);
 selectst(handle,34,ebqflg);

 tempbinary=binary;
 tempswcapr=swcapr;
 tempebqflg=ebqflg;
 tempbctr=bctr;

 kwrbc();

 xasciiwrchar(handle,35,ebq);

 return(handle);
}

